package com.newviews.tcmip.common.utils;

import java.util.HashMap;
import java.util.Map;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * 字符串操作的工具类
 *
 * @author ChenLong
 */
public class StringUtils extends org.apache.commons.lang3.StringUtils {

    private static final Pattern pattern1 = Pattern.compile("_(\\w)");
    private static final Pattern pattern2 = Pattern.compile("[A-Z]");

    /**
     * 下划线转驼峰命名，例如：user_name 返回 userName
     */
    public static StringBuffer camel(StringBuffer str) {
        //利用正则删除下划线，把下划线后一位改成大写
        Matcher matcher = pattern1.matcher(str);
        StringBuffer sb = new StringBuffer(str);
        if (matcher.find()) {
            sb = new StringBuffer();
            //将当前匹配子串替换为指定字符串，并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个StringBuffer对象里。
            //正则之前的字符和被替换的字符
            matcher.appendReplacement(sb, matcher.group(1).toUpperCase());
            //把之后的也添加到StringBuffer对象里
            matcher.appendTail(sb);
        } else {
            return sb;
        }
        return camel(sb);
    }


    /**
     * 驼峰命名方式转下划线 例如：userName 返回 user_name
     */
    public static StringBuffer underline(StringBuffer str) {
        Matcher matcher = pattern2.matcher(str);
        StringBuffer sb = new StringBuffer(str);
        if (matcher.find()) {
            sb = new StringBuffer();
            //将当前匹配子串替换为指定字符串，并且将替换后的子串以及其之前到上次匹配子串之后的字符串段添加到一个StringBuffer对象里。
            //正则之前的字符和被替换的字符
            matcher.appendReplacement(sb, "_" + matcher.group(0).toLowerCase());
            //把之后的也添加到StringBuffer对象里
            matcher.appendTail(sb);
        } else {
            return sb;
        }
        return underline(sb);
    }


    /**
     * 把null 转换为""
     */
    public static String toEmpty(String str) {
        if (str == null) {
            return "";
        }
        return str;
    }

    /**
     * 把 "" 转换为 null
     */
    public static String toNull(String str) {
        if ("".equals(str)) {
            return null;
        }
        return str;
    }


    /**
     * 取hash值
     */
    public static int toHash(String key) {
        int arraySize = 11113; // 数组大小一般取质数
        int hashCode = 0;
        for (int i = 0; i < key.length(); i++) { // 从字符串的左边开始计算
            int letterValue = key.charAt(i) - 96;// 将获取到的字符串转换成数字，比如a的码值是97，则97-96=1
            // 就代表a的值，同理b=2；
            hashCode = ((hashCode << 5) + letterValue) % arraySize;// 防止编码溢出，对每步结果都进行取模运算
        }
        return hashCode;
    }


    /**
     * 替换最后出现的位置的字符串
     *
     * @param text            原始值
     * @param strToReplace    被替换的值
     * @param replaceWithThis 替换的值
     * @return 替换后的值
     */
    public static String replaceLast(String text, String strToReplace, String replaceWithThis) {
        return text.replaceFirst("(?s)" + strToReplace + "(?!.*?" + strToReplace + ")", replaceWithThis);
    }

    /**
     * 非空判断
     * “-” 会判定为空
     */
    public static boolean myEquals(String cs1, String cs2) {
        if (StringUtils.isBlank(cs1) || "-".equals(cs1)) {
            cs1 = null;
        }
        if (StringUtils.isBlank(cs2) || "-".equals(cs2)) {
            cs2 = null;
        }

        if (cs1 == cs2) {
            return true;
        }

        if (cs1 == null || cs2 == null) {
            return false;
        }

        return cs1.equals(cs2);

    }


    /**
     * 按符号拆分字符串
     *
     * @param str    被分解的字符串
     * @param symbol 分隔符
     * @return HashMap
     */
    public static Map<String, String> splitToMap(String str, String symbol) {
        if (StringUtils.isBlank(str)) {
            return new HashMap<>();
        }

        String[] arr = str.split(symbol);
        Map<String, String> resMap = new HashMap<>(arr.length);
        for (String s : arr) {
            resMap.put(s, s);
        }
        return resMap;
    }


    /**
     * 非空判断
     * “-” “/” "\"都会判定为空
     *
     * @param str 判断的内容
     */
    public static boolean isMyBlank(String str) {
        if (str == null || str.trim().length() == 0
                || "-".equals(str) || "/".equals(str) || "\\".equals(str)) {
            return true;
        }
        return false;
    }


    /**
     * 判断是否为数字
     * type = 1  数字
     * type = 2  零和非零开头的数字
     * type = 3  带1-2位小数的正数或负数
     * type = 4  正数、负数、和小数
     * type = 5  有两位小数的正实数
     * type = 6  正整数，不含0
     * type = 7  负整数，不含0
     * type = 8  非负整数
     * type = 9  非正整数
     * type = 10  非负浮点数
     * type = 11  非正浮点数
     * type = 12  正浮点数
     * type = 13  负浮点数
     * type = 14  浮点数
     * type = 15  正实数，不含0
     * type = 16  正实数，含0
     * type = 17  正整数，含0
     * type = 18  正整数，不含0
     */
    public static boolean isInteger(String str, int type) {
        if (StringUtils.isMyBlank(str)) {
            return false;
        }
        Pattern pattern;
//        if (type == 1) {
//            pattern = Pattern.compile("^[0-9]*$");
//        } else if (type == 2) {
//            pattern = Pattern.compile("^(0|[1-9][0-9]*)$");
//        } else if (type == 3) {
//            pattern = Pattern.compile("^(\\-)?\\d+(\\.\\d{1,2})?$");
//        } else if (type == 4) {
//            pattern = Pattern.compile("^(\\-|\\+)?\\d+(\\.\\d+)?$");
//        } else if (type == 5) {
//            pattern = Pattern.compile("^[0-9]+(.[0-9]{2})?$");
//        } else if (type == 6) {
//            pattern = Pattern.compile("^([1-9][0-9]*){1,3}$");
//        } else if (type == 7) {
//            pattern = Pattern.compile("^-[1-9]\\d*$");
//        } else if (type == 8) {
//            pattern = Pattern.compile("^\\d+$");
//        } else if (type == 9) {
//            pattern = Pattern.compile("^-[1-9]\\d*|0$");
//        } else if (type == 10) {
//            pattern = Pattern.compile("^\\d+(\\.\\d+)?$");
//        } else if (type == 11) {
//            pattern = Pattern.compile("^((-\\d+(\\.\\d+)?)|(0+(\\.0+)?))$");
//        } else if (type == 12) {
//            pattern = Pattern.compile("^[1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*$");
//        } else if (type == 13) {
//            pattern = Pattern.compile("^-([1-9]\\d*\\.\\d*|0\\.\\d*[1-9]\\d*)");
//        } else if (type == 14) {
//            pattern = Pattern.compile("^(-?\\d+)(\\.\\d+)?$");
//        } else if (type == 15) {
//            pattern = Pattern.compile("^(?:[1-9][0-9]*\\.[0-9]+|0\\.(?!0+$)[0-9]+|[1-9]+\\d*)$");
//        } else if (type == 16) {
//            pattern = Pattern.compile("^(?:[1-9]\\d*|0)(?:\\.\\d+)?$");
//        } else if (type == 17) {
//            pattern = Pattern.compile("^(0|[1-9][0-9]*)$");
//        } else if (type == 18) {
//            pattern = Pattern.compile("^\\+?[1-9][0-9]*$");
//        } else {
//            return false;
//        }
//        return pattern.matcher(str).matches();
        return true;
    }



    /**
     * 比较source中是否包含contains，忽略大小写
     * @param source
     * @param contains
     * @return
     */
    public static boolean containsIgnoreCase(String source,String contains){
        if(StringUtils.isNotBlank(source)&& StringUtils.isNotBlank(contains)){
            return source.toUpperCase().contains(contains.toUpperCase());
        }
        return false;
    }


}
